<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
        <head>
          <title>prolog.fluents.DataBase</title>
          <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
          
      <link type="text/css" media="screen" rel="stylesheet" href="../../lib/template.css" />
      <script type="text/javascript" src="../../lib/jquery.js"></script>
      <script type="text/javascript" src="../../lib/jquery-ui.js"></script>
      <script type="text/javascript" src="../../lib/template.js"></script>
      <script type="text/javascript" src="../../lib/tools.tooltip.js"></script>
    
        </head>
        <body onload="sh_highlightDocument('../lib/', '.min.js');" class="type">
      <div id="definition">
        <a title="Go to companion" href="DataBase$.html"><img src="../../lib/class_to_object_big.png" /></a>
        <p id="owner"><a name="prolog" class="extype" href="../package.html">prolog</a>.<a name="prolog.fluents" class="extype" href="package.html">fluents</a></p>
        <h1><a title="Go to companion" href="DataBase$.html">DataBase</a></h1>
      </div>

      <h4 class="signature" id="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">class</span>
      </span>
      <span class="symbol">
        <span class="name">DataBase</span><span class="result"> extends <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      
      <div class="fullcommenttop" id="comment"><div class="toggleContainer block">
          <span class="toggle">Linear Supertypes</span>
          <div class="superTypes hiddenContent"><span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], <span name="scala.Serializable" class="extype">Serializable</span>, <span name="java.io.Serializable" class="extype">Serializable</span>, <span name="scala.collection.mutable.HashTable" class="extype">HashTable</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.mutable.HashTable.HashUtils" class="extype">HashUtils</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>], <span name="scala.collection.mutable.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], <span name="scala.collection.mutable.MapLike" class="extype">MapLike</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]], <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.mutable.Cloneable" class="extype">Cloneable</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.generic.Shrinkable" class="extype">Shrinkable</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>], <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.generic.Growable" class="extype">Growable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])], <span name="scala.collection.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], <span name="scala.collection.MapLike" class="extype">MapLike</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]], <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.generic.Subtractable" class="extype">Subtractable</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>) ⇒ <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]], <span name="scala.collection.GenMap" class="extype">GenMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], <span name="scala.collection.GenMapLike" class="extype">GenMapLike</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]], <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])], <span name="scala.collection.Iterable" class="extype">Iterable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])], <span name="scala.collection.IterableLike" class="extype">IterableLike</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.Equals" class="extype">Equals</span>, <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])], <span name="scala.collection.GenIterableLike" class="extype">GenIterableLike</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.mutable.Traversable" class="extype">Traversable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])], <span name="scala.Mutable" class="extype">Mutable</span>, <span name="scala.collection.Traversable" class="extype">Traversable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])], <span name="scala.collection.GenTraversable" class="extype">GenTraversable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])], <span name="scala.collection.generic.GenericTraversableTemplate" class="extype">GenericTraversableTemplate</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>], <span name="scala.collection.TraversableLike" class="extype">TraversableLike</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.GenTraversableLike" class="extype">GenTraversableLike</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.Parallelizable" class="extype">Parallelizable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.parallel.mutable.ParMap" class="extype">ParMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])], <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])], <span name="scala.collection.generic.FilterMonadic" class="extype">FilterMonadic</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], <span name="scala.collection.generic.HasNewBuilder" class="extype">HasNewBuilder</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]], AnyRef, <span name="scala.Any" class="extype">Any</span></div>
        </div></div>
    

      <div id="mbrsel">
        <div id="textfilter"><span class="pre"></span><span class="input"><input accesskey="/" type="text" /></span><span class="post"></span></div>
        <div id="order">
              <span class="filtertype">Ordering</span>
              <ol><li class="alpha in"><span>Alphabetic</span></li><li class="inherit out"><span>By inheritance</span></li></ol>
            </div>
        <div id="ancestors">
              <span class="filtertype">Inherited</span>
              <ol><li class="hideall out"><span>Hide All</span></li>
              <li class="showall in"><span>Show all</span></li></ol>
              <ol id="linearization"><li name="prolog.fluents.DataBase" class="in"><span>DataBase</span></li><li name="scala.collection.mutable.LinkedHashMap" class="in"><span>LinkedHashMap</span></li><li name="scala.Serializable" class="in"><span>Serializable</span></li><li name="java.io.Serializable" class="in"><span>Serializable</span></li><li name="scala.collection.mutable.HashTable" class="in"><span>HashTable</span></li><li name="scala.collection.mutable.HashTable.HashUtils" class="in"><span>HashUtils</span></li><li name="scala.collection.mutable.Map" class="in"><span>Map</span></li><li name="scala.collection.mutable.MapLike" class="in"><span>MapLike</span></li><li name="scala.collection.mutable.Cloneable" class="in"><span>Cloneable</span></li><li name="scala.collection.generic.Shrinkable" class="in"><span>Shrinkable</span></li><li name="scala.collection.mutable.Builder" class="in"><span>Builder</span></li><li name="scala.collection.generic.Growable" class="in"><span>Growable</span></li><li name="scala.collection.Map" class="in"><span>Map</span></li><li name="scala.collection.MapLike" class="in"><span>MapLike</span></li><li name="scala.collection.generic.Subtractable" class="in"><span>Subtractable</span></li><li name="scala.PartialFunction" class="in"><span>PartialFunction</span></li><li name="scala.Function1" class="in"><span>Function1</span></li><li name="scala.collection.GenMap" class="in"><span>GenMap</span></li><li name="scala.collection.GenMapLike" class="in"><span>GenMapLike</span></li><li name="scala.collection.mutable.Iterable" class="in"><span>Iterable</span></li><li name="scala.collection.Iterable" class="in"><span>Iterable</span></li><li name="scala.collection.IterableLike" class="in"><span>IterableLike</span></li><li name="scala.Equals" class="in"><span>Equals</span></li><li name="scala.collection.GenIterable" class="in"><span>GenIterable</span></li><li name="scala.collection.GenIterableLike" class="in"><span>GenIterableLike</span></li><li name="scala.collection.mutable.Traversable" class="in"><span>Traversable</span></li><li name="scala.Mutable" class="in"><span>Mutable</span></li><li name="scala.collection.Traversable" class="in"><span>Traversable</span></li><li name="scala.collection.GenTraversable" class="in"><span>GenTraversable</span></li><li name="scala.collection.generic.GenericTraversableTemplate" class="in"><span>GenericTraversableTemplate</span></li><li name="scala.collection.TraversableLike" class="in"><span>TraversableLike</span></li><li name="scala.collection.GenTraversableLike" class="in"><span>GenTraversableLike</span></li><li name="scala.collection.Parallelizable" class="in"><span>Parallelizable</span></li><li name="scala.collection.TraversableOnce" class="in"><span>TraversableOnce</span></li><li name="scala.collection.GenTraversableOnce" class="in"><span>GenTraversableOnce</span></li><li name="scala.collection.generic.FilterMonadic" class="in"><span>FilterMonadic</span></li><li name="scala.collection.generic.HasNewBuilder" class="in"><span>HasNewBuilder</span></li><li name="scala.AnyRef" class="in"><span>AnyRef</span></li><li name="scala.Any" class="in"><span>Any</span></li></ol>
            </div>
        <div id="visbl">
            <span class="filtertype">Visibility</span>
            <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
          </div>
      </div>

      <div id="template">
        <div id="allMembers">
        <div class="members" id="constructors">
              <h3>Instance Constructors</h3>
              <ol><li visbl="pub" name="prolog.fluents.DataBase#this" data-isabs="false">
      <a id="this:DataBase"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">new</span>
      </span>
      <span class="symbol">
        <span class="name">DataBase</span><span class="params">(<span name="name">name: String</span>, <span name="cs">cs: List[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>)</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.fluents.DataBase#this" data-isabs="false">
      <a id="this:DataBase"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">new</span>
      </span>
      <span class="symbol">
        <span class="name">DataBase</span><span class="params">()</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.fluents.DataBase#this" data-isabs="false">
      <a id="this:DataBase"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">new</span>
      </span>
      <span class="symbol">
        <span class="name">DataBase</span><span class="params">(<span name="fname">fname: String</span>)</span>
      </span>
      </h4>
      
    </li></ol>
            </div>

        <div class="types members" id="types">
              <h3>Type Members</h3>
              <ol><li visbl="pub" name="prolog.fluents.DataBase#CLAUSE" data-isabs="false">
      <a id="CLAUSE:CLAUSE"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">type</span>
      </span>
      <span class="symbol">
        <span class="name">CLAUSE</span><span class="result"> = <span name="scala.collection.immutable.List" class="extype">List</span>[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#Entry" data-isabs="false">
      <a id="Entry:Entry"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">type</span>
      </span>
      <span class="symbol">
        <span class="name">Entry</span><span class="result"> = <span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.TraversableLike#Self" data-isabs="false">
      <a id="Self:Self"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">type</span>
      </span>
      <span class="symbol">
        <span class="name">Self</span><span class="result"> = <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li></ol>
            </div>

        

        <div class="values members" id="values">
              <h3>Value Members</h3>
              <ol><li visbl="pub" name="scala.AnyRef#!=" data-isabs="false">
      <a id="!=(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $bang$eq">!=</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#!=" data-isabs="false">
      <a id="!=(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $bang$eq">!=</span><span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef###" data-isabs="false">
      <a id="##():Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $hash$hash">##</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#+" data-isabs="false">
      <a id="+[B1&gt;:Deque[List[Term]]]((Key, B1),(Key, B1),(Key, B1)*):Map[Key, B1]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus">+</span><span class="tparams">[<span name="B1">B1 &gt;: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>]</span><span class="params">(<span name="elem1">elem1: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, B1)</span>, <span name="elem2">elem2: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, B1)</span>, <span name="elems">elems: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, B1)*</span>)</span><span class="result">: <span name="scala.collection.mutable.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, B1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → MapLike</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.8.0)</i> <code>+</code> creates a new map. Use <code>+=</code> to add an element to this map and return that map itself.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#+" data-isabs="false">
      <a id="+[B1&gt;:Deque[List[Term]]]((Key, B1)):Map[Key, B1]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus">+</span><span class="tparams">[<span name="B1">B1 &gt;: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>]</span><span class="params">(<span name="kv">kv: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, B1)</span>)</span><span class="result">: <span name="scala.collection.mutable.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, B1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → MapLike → GenMapLike</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.8.0)</i> <code>+</code> creates a new map. Use <code>+=</code> to add an element to this map and return that map itself.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#++" data-isabs="false">
      <a id="++[B1&gt;:Deque[List[Term]]](GenTraversableOnce[(Key, B1)]):Map[Key, B1]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus$plus">++</span><span class="tparams">[<span name="B1">B1 &gt;: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>]</span><span class="params">(<span name="xs">xs: <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, B1)]</span>)</span><span class="result">: <span name="scala.collection.mutable.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, B1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → MapLike</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.8.0)</i> <code>++</code> creates a new map. Use <code>++=</code> to add an element to this map and return that map itself.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++" data-isabs="false">
      <a id="++[B&gt;:(Key, Deque[List[Term]]), That](GenTraversableOnce[B])(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], B, That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus$plus">++</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>, <span name="That">That</span>]</span><span class="params">(<span name="that">that: <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++:" data-isabs="false">
      <a id="++:[B&gt;:(Key, Deque[List[Term]]), That](Traversable[B])(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], B, That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus$plus$colon">++:</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>, <span name="That">That</span>]</span><span class="params">(<span name="that">that: <span name="scala.collection.Traversable" class="extype">Traversable</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#++:" data-isabs="false">
      <a id="++:[B&gt;:(Key, Deque[List[Term]]), That](TraversableOnce[B])(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], B, That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus$plus$colon">++:</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>, <span name="That">That</span>]</span><span class="params">(<span name="that">that: <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.Growable#++=" data-isabs="false">
      <a id="++=(TraversableOnce[(Key, Deque[List[Term]])]):DataBase.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus$plus$eq">++=</span><span class="params">(<span name="xs">xs: <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>)</span><span class="result">: DataBase.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Growable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#+=" data-isabs="false">
      <a id="+=((Key, Deque[List[Term]])):DataBase.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus$eq">+=</span><span class="params">(<span name="kv">kv: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>)</span><span class="result">: DataBase.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → MapLike → Builder → Growable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.Growable#+=" data-isabs="false">
      <a id="+=((Key, Deque[List[Term]]),(Key, Deque[List[Term]]),(Key, Deque[List[Term]])*):DataBase.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $plus$eq">+=</span><span class="params">(<span name="elem1">elem1: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>, <span name="elem2">elem2: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>, <span name="elems">elems: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])*</span>)</span><span class="result">: DataBase.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Growable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#-" data-isabs="false">
      <a id="-(Key,Key,Key*):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $minus">-</span><span class="params">(<span name="elem1">elem1: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="elem2">elem2: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="elems">elems: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>*</span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → Subtractable</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.8.0)</i> <code>-</code> creates a new map. Use <code>-=</code> to remove an element from this map and return that map itself.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#-" data-isabs="false">
      <a id="-(Key):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $minus">-</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → MapLike → Subtractable → GenMapLike</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.8.0)</i> <code>-</code> creates a new map. Use <code>-=</code> to remove an element from this map and return that map itself.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#--" data-isabs="false">
      <a id="--(GenTraversableOnce[Key]):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $minus$minus">--</span><span class="params">(<span name="xs">xs: <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>]</span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → Subtractable</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.8.0)</i> <code>--</code> creates a new map. Use <code>--=</code> to remove an element from this map and return that map itself.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.Shrinkable#--=" data-isabs="false">
      <a id="--=(TraversableOnce[Key]):DataBase.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $minus$minus$eq">--=</span><span class="params">(<span name="xs">xs: <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>]</span>)</span><span class="result">: DataBase.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Shrinkable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#-=" data-isabs="false">
      <a id="-=(Key):DataBase.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $minus$eq">-=</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: DataBase.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → MapLike → Shrinkable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.Shrinkable#-=" data-isabs="false">
      <a id="-=(Key,Key,Key*):DataBase.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $minus$eq">-=</span><span class="params">(<span name="elem1">elem1: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="elem2">elem2: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="elems">elems: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>*</span>)</span><span class="result">: DataBase.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Shrinkable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#/:" data-isabs="false">
      <a id="/:[B](B)((B, (Key, Deque[List[Term]])) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $div$colon">/:</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenTraversableOnce#/:\" data-isabs="false">
      <a id="/:\[A1&gt;:(Key, Deque[List[Term]])](A1)((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $div$colon$bslash">/:\</span><span class="tparams">[<span name="A1">A1 &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="z">z: A1</span>)</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#:\" data-isabs="false">
      <a id=":\[B](B)(((Key, Deque[List[Term]]), B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $colon$bslash">:\</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#==" data-isabs="false">
      <a id="==(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $eq$eq">==</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#==" data-isabs="false">
      <a id="==(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name" title="gt4s: $eq$eq">==</span><span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#_loadFactor" data-isabs="false">
      <a id="_loadFactor:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">_loadFactor</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#add" data-isabs="false">
      <a id="add(CLAUSE):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">add</span><span class="params">(<span name="c">c: CLAUSE</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.fluents.DataBase#addAll" data-isabs="false">
      <a id="addAll(List[CLAUSE]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">addAll</span><span class="params">(<span name="cs">cs: List[CLAUSE]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#addEntry" data-isabs="false">
      <a id="addEntry(LinkedEntry[Key, Deque[List[Term]]]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">addEntry</span><span class="params">(<span name="e">e: <span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#addString" data-isabs="false">
      <a id="addString(StringBuilder,String,String,String):StringBuilder"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">addString</span><span class="params">(<span name="b">b: StringBuilder</span>, <span name="start">start: String</span>, <span name="sep">sep: String</span>, <span name="end">end: String</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder):StringBuilder"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">addString</span><span class="params">(<span name="b">b: StringBuilder</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#addString" data-isabs="false">
      <a id="addString(StringBuilder,String):StringBuilder"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">addString</span><span class="params">(<span name="b">b: StringBuilder</span>, <span name="sep">sep: String</span>)</span><span class="result">: StringBuilder</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#add_or_exec" data-isabs="false">
      <a id="add_or_exec(CLAUSE):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">add_or_exec</span><span class="params">(<span name="c">c: CLAUSE</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.TraversableOnce#aggregate" data-isabs="false">
      <a id="aggregate[B](B)((B, (Key, Deque[List[Term]])) ⇒ B,(B, B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">aggregate</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="seqop">seqop: (B, (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ B</span>, <span name="combop">combop: (B, B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#alwaysInitSizeMap" data-isabs="false">
      <a id="alwaysInitSizeMap:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">alwaysInitSizeMap</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.PartialFunction#andThen" data-isabs="false">
      <a id="andThen[C]((Deque[List[Term]]) ⇒ C):PartialFunction[Key, C]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">andThen</span><span class="tparams">[<span name="C">C</span>]</span><span class="params">(<span name="k">k: (<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]) ⇒ C</span>)</span><span class="result">: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, C]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>PartialFunction → Function1</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#apply" data-isabs="false">
      <a id="apply(Key):Deque[List[Term]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">apply</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → GenMapLike → Function1</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#asInstanceOf" data-isabs="false">
      <a id="asInstanceOf[T0]:T0"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">asInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#calcSizeMapSize" data-isabs="false">
      <a id="calcSizeMapSize(Int):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">calcSizeMapSize</span><span class="params">(<span name="tableLength">tableLength: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#canEqual" data-isabs="false">
      <a id="canEqual(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">canEqual</span><span class="params">(<span name="that">that: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → Equals</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#cleanUpKey" data-isabs="false">
      <a id="cleanUpKey(Term):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">cleanUpKey</span><span class="params">(<span name="h">h: <a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#clear" data-isabs="false">
      <a id="clear():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">clear</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → MapLike → Builder → Growable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#clearTable" data-isabs="false">
      <a id="clearTable():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">clearTable</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#clone" data-isabs="false">
      <a id="clone():LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">clone</span><span class="params">()</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → Cloneable → AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#collect" data-isabs="false">
      <a id="collect[B, That](PartialFunction[(Key, Deque[List[Term]]), B])(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], B, That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">collect</span><span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span><span class="params">(<span name="pf">pf: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#collectFirst" data-isabs="false">
      <a id="collectFirst[B](PartialFunction[(Key, Deque[List[Term]]), B]):Option[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">collectFirst</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="pf">pf: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), B]</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Iterable#companion" data-isabs="false">
      <a id="companion:GenericCompanion[Iterable]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">companion</span><span class="result">: <span name="scala.collection.generic.GenericCompanion" class="extype">GenericCompanion</span>[<span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.Function1#compose" data-isabs="false">
      <a id="compose[A]((A) ⇒ Key):(A) ⇒ Deque[List[Term]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">compose</span><span class="tparams">[<span name="A">A</span>]</span><span class="params">(<span name="g">g: (A) ⇒ <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: (A) ⇒ <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Function1</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#contains" data-isabs="false">
      <a id="contains(Key):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">contains</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:(Key, Deque[List[Term]])](Array[B],Int,Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">copyToArray</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>, <span name="len">len: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:(Key, Deque[List[Term]])](Array[B]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">copyToArray</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToArray" data-isabs="false">
      <a id="copyToArray[B&gt;:(Key, Deque[List[Term]])](Array[B],Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">copyToArray</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="xs">xs: <span name="scala.Array" class="extype">Array</span>[B]</span>, <span name="start">start: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#copyToBuffer" data-isabs="false">
      <a id="copyToBuffer[B&gt;:(Key, Deque[List[Term]])](Buffer[B]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">copyToBuffer</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="dest">dest: <span name="scala.collection.mutable.Buffer" class="extype">Buffer</span>[B]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#count" data-isabs="false">
      <a id="count(((Key, Deque[List[Term]])) ⇒ Boolean):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">count</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#default" data-isabs="false">
      <a id="default(Key):Deque[List[Term]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">default</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → GenMapLike</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#del1" data-isabs="false">
      <a id="del1(Term):List[Term]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">del1</span><span class="params">(<span name="h">h: <a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a></span>)</span><span class="result">: List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.fluents.DataBase#delAll" data-isabs="false">
      <a id="delAll(Term):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">delAll</span><span class="params">(<span name="h">h: <a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.IterableLike#drop" data-isabs="false">
      <a id="drop(Int):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">drop</span><span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#dropRight" data-isabs="false">
      <a id="dropRight(Int):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">dropRight</span><span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#dropWhile" data-isabs="false">
      <a id="dropWhile(((Key, Deque[List[Term]])) ⇒ Boolean):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">dropWhile</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#elemEquals" data-isabs="false">
      <a id="elemEquals(Key,Key):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">elemEquals</span><span class="params">(<span name="key1">key1: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="key2">key2: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable.HashUtils#elemHashCode" data-isabs="false">
      <a id="elemHashCode(Key):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">elemHashCode</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashUtils</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#empty" data-isabs="false">
      <a id="empty:LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">empty</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → Map → Map → MapLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#entriesIterator" data-isabs="false">
      <a id="entriesIterator:Iterator[LinkedEntry[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">entriesIterator</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#eq" data-isabs="false">
      <a id="eq(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">eq</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenMapLike#equals" data-isabs="false">
      <a id="equals(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">equals</span><span class="params">(<span name="that">that: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenMapLike → Equals → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#exec_cmd" data-isabs="false">
      <a id="exec_cmd(CLAUSE):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">exec_cmd</span><span class="params">(<span name="body">body: CLAUSE</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.IterableLike#exists" data-isabs="false">
      <a id="exists(((Key, Deque[List[Term]])) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">exists</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#filter" data-isabs="false">
      <a id="filter(((Key, Deque[List[Term]])) ⇒ Boolean):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">filter</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#filterKeys" data-isabs="false">
      <a id="filterKeys((Key) ⇒ Boolean):Map[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">filterKeys</span><span class="params">(<span name="p">p: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#filterNot" data-isabs="false">
      <a id="filterNot(((Key, Deque[List[Term]])) ⇒ Boolean):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">filterNot</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.AnyRef#finalize" data-isabs="false">
      <a id="finalize():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">finalize</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#find" data-isabs="false">
      <a id="find(((Key, Deque[List[Term]])) ⇒ Boolean):Option[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">find</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#findEntry" data-isabs="false">
      <a id="findEntry(Key):LinkedEntry[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">findEntry</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.LinkedHashMap#firstEntry" data-isabs="false">
      <a id="firstEntry:Entry"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">firstEntry</span><span class="result">: Entry</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>LinkedHashMap</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#flatMap" data-isabs="false">
      <a id="flatMap[B, That](((Key, Deque[List[Term]])) ⇒ GenTraversableOnce[B])(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], B, That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">flatMap</span><span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span><span class="params">(<span name="f">f: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#fold" data-isabs="false">
      <a id="fold[A1&gt;:(Key, Deque[List[Term]])](A1)((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">fold</span><span class="tparams">[<span name="A1">A1 &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="z">z: A1</span>)</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#foldLeft" data-isabs="false">
      <a id="foldLeft[B](B)((B, (Key, Deque[List[Term]])) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foldLeft</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#foldRight" data-isabs="false">
      <a id="foldRight[B](B)(((Key, Deque[List[Term]]), B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foldRight</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#forall" data-isabs="false">
      <a id="forall(((Key, Deque[List[Term]])) ⇒ Boolean):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">forall</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#foreach" data-isabs="false">
      <a id="foreach[U](((Key, Deque[List[Term]])) ⇒ U):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foreach</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ U</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → IterableLike → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#foreachEntry" data-isabs="false">
      <a id="foreachEntry[C]((LinkedEntry[Key, Deque[List[Term]]]) ⇒ C):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foreachEntry</span><span class="tparams">[<span name="C">C</span>]</span><span class="params">(<span name="f">f: (<span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]) ⇒ C</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#fromFile" data-isabs="false">
      <a id="fromFile(String,Boolean):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">fromFile</span><span class="params">(<span name="f0">f0: String</span>, <span name="doClear">doClear: <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#genericBuilder" data-isabs="false">
      <a id="genericBuilder[B]:Builder[B, Iterable[B]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">genericBuilder</span><span class="tparams">[<span name="B">B</span>]</span><span class="result">: <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[B, <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[B]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#get" data-isabs="false">
      <a id="get(Key):Option[Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">get</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → MapLike → GenMapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#getClass" data-isabs="false">
      <a id="getClass():java.lang.Class[_]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getClass</span><span class="params">()</span><span class="result">: java.lang.Class[_]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#getMatches" data-isabs="false">
      <a id="getMatches(CLAUSE,Boolean):Deque[CLAUSE]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getMatches</span><span class="params">(<span name="c">c: CLAUSE</span>, <span name="verbose">verbose: <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[CLAUSE]</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.fluents.DataBase#getMatches" data-isabs="false">
      <a id="getMatches(CLAUSE):Deque[CLAUSE]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getMatches</span><span class="params">(<span name="c">c: CLAUSE</span>)</span><span class="result">: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[CLAUSE]</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.MapLike#getOrElse" data-isabs="false">
      <a id="getOrElse[B1&gt;:Deque[List[Term]]](Key,⇒ B1):B1"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getOrElse</span><span class="tparams">[<span name="B1">B1 &gt;: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>]</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="default">default: ⇒ B1</span>)</span><span class="result">: B1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#getOrElseUpdate" data-isabs="false">
      <a id="getOrElseUpdate(Key,⇒ Deque[List[Term]]):Deque[List[Term]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getOrElseUpdate</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="op">op: ⇒ <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>)</span><span class="result">: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#groupBy" data-isabs="false">
      <a id="groupBy[K](((Key, Deque[List[Term]])) ⇒ K):Map[K, LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">groupBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ K</span>)</span><span class="result">: <span name="scala.collection.immutable.Map" class="extype">Map</span>[K, <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#grouped" data-isabs="false">
      <a id="grouped(Int):Iterator[LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">grouped</span><span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#hasDefiniteSize" data-isabs="false">
      <a id="hasDefiniteSize:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">hasDefiniteSize</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#has_clauses" data-isabs="false">
      <a id="has_clauses(Term):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">has_clauses</span><span class="params">(<span name="h">h: <a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.GenMapLike#hashCode" data-isabs="false">
      <a id="hashCode():Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">hashCode</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenMapLike → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#head" data-isabs="false">
      <a id="head:(Key, Deque[List[Term]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">head</span><span class="result">: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → GenIterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#headOption" data-isabs="false">
      <a id="headOption:Option[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">headOption</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable.HashUtils#improve" data-isabs="false">
      <a id="improve(Int):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">improve</span><span class="params">(<span name="hcode">hcode: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashUtils</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#index" data-isabs="false">
      <a id="index(Int):Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">index</span><span class="params">(<span name="hcode">hcode: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#init" data-isabs="false">
      <a id="init:LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">init</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#initWithContents" data-isabs="false">
      <a id="initWithContents(Contents[Key, LinkedEntry[Key, Deque[List[Term]]]]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">initWithContents</span><span class="params">(<span name="c">c: <span name="scala.collection.mutable.HashTable.Contents" class="extype">Contents</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#initialSize" data-isabs="false">
      <a id="initialSize:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">initialSize</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#inits" data-isabs="false">
      <a id="inits:Iterator[LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">inits</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#isDefinedAt" data-isabs="false">
      <a id="isDefinedAt(Key):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isDefinedAt</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → PartialFunction</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#isEmpty" data-isabs="false">
      <a id="isEmpty:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isEmpty</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → IterableLike → GenIterableLike → TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#isInstanceOf" data-isabs="false">
      <a id="isInstanceOf[T0]:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#isSizeMapDefined" data-isabs="false">
      <a id="isSizeMapDefined:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isSizeMapDefined</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.GenTraversableLike#isTraversableAgain" data-isabs="false">
      <a id="isTraversableAgain:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isTraversableAgain</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenTraversableLike → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#iterator" data-isabs="false">
      <a id="iterator:Iterator[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">iterator</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → MapLike → IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#key" data-isabs="false">
      <a id="key(Const):Key"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">key</span><span class="params">(<span name="c">c: <a name="prolog.terms.Const" class="extype" href="../terms/Const.html">Const</a></span>)</span><span class="result">: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="prolog.fluents.DataBase#key" data-isabs="false">
      <a id="key(CLAUSE):Key"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">key</span><span class="params">(<span name="c">c: CLAUSE</span>)</span><span class="result">: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.MapLike#keySet" data-isabs="false">
      <a id="keySet:Set[Key]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">keySet</span><span class="result">: <span name="scala.collection.Set" class="extype">Set</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#keys" data-isabs="false">
      <a id="keys:Iterable[Key]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">keys</span><span class="result">: <span name="scala.collection.Iterable" class="extype">Iterable</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.8.0)</i> <code>keys</code> returns <code>Iterable[A]</code> rather than <code>Iterator[A]</code>.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#keysIterator" data-isabs="false">
      <a id="keysIterator:Iterator[Key]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">keysIterator</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#last" data-isabs="false">
      <a id="last:(Key, Deque[List[Term]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">last</span><span class="result">: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.LinkedHashMap#lastEntry" data-isabs="false">
      <a id="lastEntry:Entry"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">lastEntry</span><span class="result">: Entry</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>LinkedHashMap</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#lastOption" data-isabs="false">
      <a id="lastOption:Option[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lastOption</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.PartialFunction#lift" data-isabs="false">
      <a id="lift:(Key) ⇒ Option[Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lift</span><span class="result">: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>) ⇒ <span name="scala.Option" class="extype">Option</span>[<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>PartialFunction</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#map" data-isabs="false">
      <a id="map[B, That](((Key, Deque[List[Term]])) ⇒ B)(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], B, That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">map</span><span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span><span class="params">(<span name="f">f: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Builder#mapResult" data-isabs="false">
      <a id="mapResult[NewTo]((LinkedHashMap[Key, Deque[List[Term]]]) ⇒ NewTo):Builder[(Key, Deque[List[Term]]), NewTo]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mapResult</span><span class="tparams">[<span name="NewTo">NewTo</span>]</span><span class="params">(<span name="f">f: (<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]) ⇒ NewTo</span>)</span><span class="result">: <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), NewTo]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Builder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#mapValues" data-isabs="false">
      <a id="mapValues[C]((Deque[List[Term]]) ⇒ C):Map[Key, C]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mapValues</span><span class="tparams">[<span name="C">C</span>]</span><span class="params">(<span name="f">f: (<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]) ⇒ C</span>)</span><span class="result">: <span name="scala.collection.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, C]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#max" data-isabs="false">
      <a id="max[B&gt;:(Key, Deque[List[Term]])](Ordering[B]):(Key, Deque[List[Term]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">max</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#maxBy" data-isabs="false">
      <a id="maxBy[B](((Key, Deque[List[Term]])) ⇒ B)(Ordering[B]):(Key, Deque[List[Term]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">maxBy</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="f">f: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#min" data-isabs="false">
      <a id="min[B&gt;:(Key, Deque[List[Term]])](Ordering[B]):(Key, Deque[List[Term]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">min</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#minBy" data-isabs="false">
      <a id="minBy[B](((Key, Deque[List[Term]])) ⇒ B)(Ordering[B]):(Key, Deque[List[Term]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">minBy</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span name="f">f: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cmp">cmp: Ordering[B]</span>)</span><span class="result">: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mkString</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString(String):String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mkString</span><span class="params">(<span name="sep">sep: String</span>)</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#mkString" data-isabs="false">
      <a id="mkString(String,String,String):String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mkString</span><span class="params">(<span name="start">start: String</span>, <span name="sep">sep: String</span>, <span name="end">end: String</span>)</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#ne" data-isabs="false">
      <a id="ne(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">ne</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.MapLike#newBuilder" data-isabs="false">
      <a id="newBuilder:Builder[(Key, Deque[List[Term]]), LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">newBuilder</span><span class="result">: <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>MapLike → MapLike → TraversableLike → HasNewBuilder</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#new_prog" data-isabs="false">
      <a id="new_prog(Term,List[Term]):Prog"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">new_prog</span><span class="params">(<span name="answer">answer: <a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a></span>, <span name="gs">gs: List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]</span>)</span><span class="result">: <a name="prolog.interp.Prog" class="extype" href="../interp/Prog.html">Prog</a></span>
      </span>
      </h4>
      
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#nnSizeMapAdd" data-isabs="false">
      <a id="nnSizeMapAdd(Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">nnSizeMapAdd</span><span class="params">(<span name="h">h: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#nnSizeMapRemove" data-isabs="false">
      <a id="nnSizeMapRemove(Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">nnSizeMapRemove</span><span class="params">(<span name="h">h: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#nnSizeMapReset" data-isabs="false">
      <a id="nnSizeMapReset(Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">nnSizeMapReset</span><span class="params">(<span name="tableLength">tableLength: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#nonEmpty" data-isabs="false">
      <a id="nonEmpty:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">nonEmpty</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notify" data-isabs="false">
      <a id="notify():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">notify</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notifyAll" data-isabs="false">
      <a id="notifyAll():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">notifyAll</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.PartialFunction#orElse" data-isabs="false">
      <a id="orElse[A1&lt;:Key, B1&gt;:Deque[List[Term]]](PartialFunction[A1, B1]):PartialFunction[A1, B1]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">orElse</span><span class="tparams">[<span name="A1">A1 &lt;: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="B1">B1 &gt;: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>]</span><span class="params">(<span name="that">that: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[A1, B1]</span>)</span><span class="result">: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[A1, B1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>PartialFunction</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.Parallelizable#par" data-isabs="false">
      <a id="par:ParMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">par</span><span class="result">: <span name="scala.collection.parallel.mutable.ParMap" class="extype">ParMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Parallelizable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.MapLike#parCombiner" data-isabs="false">
      <a id="parCombiner:Combiner[(Key, Deque[List[Term]]), ParMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">parCombiner</span><span class="result">: <span name="scala.collection.parallel.Combiner" class="extype">Combiner</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.parallel.mutable.ParMap" class="extype">ParMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>MapLike → MapLike → TraversableLike → Parallelizable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#partition" data-isabs="false">
      <a id="partition(((Key, Deque[List[Term]])) ⇒ Boolean):(LinkedHashMap[Key, Deque[List[Term]]], LinkedHashMap[Key, Deque[List[Term]]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">partition</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: (<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#product" data-isabs="false">
      <a id="product[B&gt;:(Key, Deque[List[Term]])](Numeric[B]):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">product</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="num">num: Numeric[B]</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#push" data-isabs="false">
      <a id="push(CLAUSE):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">push</span><span class="params">(<span name="c">c: CLAUSE</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#put" data-isabs="false">
      <a id="put(Key,Deque[List[Term]]):Option[Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">put</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="value">value: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduce" data-isabs="false">
      <a id="reduce[A1&gt;:(Key, Deque[List[Term]])]((A1, A1) ⇒ A1):A1"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduce</span><span class="tparams">[<span name="A1">A1 &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: A1</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceLeft" data-isabs="false">
      <a id="reduceLeft[B&gt;:(Key, Deque[List[Term]])]((B, (Key, Deque[List[Term]])) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceLeft</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="op">op: (B, (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceLeftOption" data-isabs="false">
      <a id="reduceLeftOption[B&gt;:(Key, Deque[List[Term]])]((B, (Key, Deque[List[Term]])) ⇒ B):Option[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceLeftOption</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="op">op: (B, (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ B</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceOption" data-isabs="false">
      <a id="reduceOption[A1&gt;:(Key, Deque[List[Term]])]((A1, A1) ⇒ A1):Option[A1]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceOption</span><span class="tparams">[<span name="A1">A1 &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="op">op: (A1, A1) ⇒ A1</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[A1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#reduceRight" data-isabs="false">
      <a id="reduceRight[B&gt;:(Key, Deque[List[Term]])](((Key, Deque[List[Term]]), B) ⇒ B):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceRight</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="op">op: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), B) ⇒ B</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#reduceRightOption" data-isabs="false">
      <a id="reduceRightOption[B&gt;:(Key, Deque[List[Term]])](((Key, Deque[List[Term]]), B) ⇒ B):Option[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduceRightOption</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="op">op: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), B) ⇒ B</span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#remove" data-isabs="false">
      <a id="remove(Key):Option[Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">remove</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → MapLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#removeEntry" data-isabs="false">
      <a id="removeEntry(Key):LinkedEntry[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">removeEntry</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#repr" data-isabs="false">
      <a id="repr:LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">repr</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#result" data-isabs="false">
      <a id="result():LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">result</span><span class="params">()</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → Builder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#retain" data-isabs="false">
      <a id="retain((Key, Deque[List[Term]]) ⇒ Boolean):DataBase.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">retain</span><span class="params">(<span name="p">p: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: DataBase.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#revVars" data-isabs="false">
      <a id="revVars():LinkedHashMap[Var, String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">revVars</span><span class="params">()</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.terms.Var" class="extype" href="../terms/Var.html">Var</a>, String]</span>
      </span>
      </h4>
      
    </li><li visbl="prt" name="scala.collection.TraversableOnce#reversed" data-isabs="false">
      <a id="reversed:List[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reversed</span><span class="result">: List[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>TraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#sameElements" data-isabs="false">
      <a id="sameElements[B&gt;:(Key, Deque[List[Term]])](GenIterable[B]):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sameElements</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="that">that: <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[B]</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#scan" data-isabs="false">
      <a id="scan[B&gt;:(Key, Deque[List[Term]]), That](B)((B, B) ⇒ B)(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], B, That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">scan</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>, <span name="That">That</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, B) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="cbf">cbf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#scanLeft" data-isabs="false">
      <a id="scanLeft[B, That](B)((B, (Key, Deque[List[Term]])) ⇒ B)(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], B, That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">scanLeft</span><span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: (B, (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#scanRight" data-isabs="false">
      <a id="scanRight[B, That](B)(((Key, Deque[List[Term]]), B) ⇒ B)(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], B, That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">scanRight</span><span class="tparams">[<span name="B">B</span>, <span name="That">That</span>]</span><span class="params">(<span name="z">z: B</span>)</span><span class="params">(<span name="op">op: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), B) ⇒ B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], B, That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.9.0)</i> The behavior of <code>scanRight</code> has changed. The previous behavior can be reproduced with scanRight.reverse.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Map#seq" data-isabs="false">
      <a id="seq:Map[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">seq</span><span class="result">: <span name="scala.collection.mutable.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Map → Map → GenMap → GenMapLike → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#size" data-isabs="false">
      <a id="size:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">size</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → GenTraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Builder#sizeHint" data-isabs="false">
      <a id="sizeHint(scala.collection.TraversableLike[_, _],Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sizeHint</span><span class="params">(<span name="coll">coll: scala.collection.TraversableLike[_, _]</span>, <span name="delta">delta: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Builder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Builder#sizeHint" data-isabs="false">
      <a id="sizeHint(Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sizeHint</span><span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Builder</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Builder#sizeHintBounded" data-isabs="false">
      <a id="sizeHintBounded(Int,scala.collection.TraversableLike[_, _]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sizeHintBounded</span><span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>, <span name="boundingColl">boundingColl: scala.collection.TraversableLike[_, _]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Builder</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable.HashUtils#sizeMapBucketBitSize" data-isabs="false">
      <a id="sizeMapBucketBitSize:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sizeMapBucketBitSize</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashUtils</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable.HashUtils#sizeMapBucketSize" data-isabs="false">
      <a id="sizeMapBucketSize:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sizeMapBucketSize</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashUtils</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#sizeMapDisable" data-isabs="false">
      <a id="sizeMapDisable():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sizeMapDisable</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#sizeMapInit" data-isabs="false">
      <a id="sizeMapInit(Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sizeMapInit</span><span class="params">(<span name="tableLength">tableLength: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#sizeMapInitAndRebuild" data-isabs="false">
      <a id="sizeMapInitAndRebuild():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sizeMapInitAndRebuild</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#sizemap" data-isabs="false">
      <a id="sizemap:Array[Int]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">sizemap</span><span class="result">: <span name="scala.Array" class="extype">Array</span>[<span name="scala.Int" class="extype">Int</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#slice" data-isabs="false">
      <a id="slice(Int,Int):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">slice</span><span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="until">until: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#sliding" data-isabs="false">
      <a id="sliding[B&gt;:(Key, Deque[List[Term]])](Int,Int):Iterator[LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sliding</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>, <span name="step">step: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#sliding" data-isabs="false">
      <a id="sliding[B&gt;:(Key, Deque[List[Term]])](Int):Iterator[LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sliding</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span name="size">size: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#span" data-isabs="false">
      <a id="span(((Key, Deque[List[Term]])) ⇒ Boolean):(LinkedHashMap[Key, Deque[List[Term]]], LinkedHashMap[Key, Deque[List[Term]]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">span</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: (<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#splitAt" data-isabs="false">
      <a id="splitAt(Int):(LinkedHashMap[Key, Deque[List[Term]]], LinkedHashMap[Key, Deque[List[Term]]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">splitAt</span><span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: (<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#stringPrefix" data-isabs="false">
      <a id="stringPrefix:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">stringPrefix</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#sum" data-isabs="false">
      <a id="sum[B&gt;:(Key, Deque[List[Term]])](Numeric[B]):B"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sum</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="num">num: Numeric[B]</span>)</span><span class="result">: B</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#synchronized" data-isabs="false">
      <a id="synchronized[T0](⇒ T0):T0"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">synchronized</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="params">(<span name="arg0">arg0: ⇒ T0</span>)</span><span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#table" data-isabs="false">
      <a id="table:Array[HashEntry[Key, LinkedEntry[Key, Deque[List[Term]]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">table</span><span class="result">: <span name="scala.Array" class="extype">Array</span>[<span name="scala.collection.mutable.HashEntry" class="extype">HashEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#tableSize" data-isabs="false">
      <a id="tableSize:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">tableSize</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#tail" data-isabs="false">
      <a id="tail:LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">tail</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#tails" data-isabs="false">
      <a id="tails:Iterator[LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">tails</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#take" data-isabs="false">
      <a id="take(Int):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">take</span><span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#takeRight" data-isabs="false">
      <a id="takeRight(Int):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">takeRight</span><span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#takeWhile" data-isabs="false">
      <a id="takeWhile(((Key, Deque[List[Term]])) ⇒ Boolean):LinkedHashMap[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">takeWhile</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → GenTraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.IterableLike#thisCollection" data-isabs="false">
      <a id="thisCollection:Iterable[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">thisCollection</span><span class="result">: <span name="scala.collection.Iterable" class="extype">Iterable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#threshold" data-isabs="false">
      <a id="threshold:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">threshold</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toArray" data-isabs="false">
      <a id="toArray[B&gt;:(Key, Deque[List[Term]])](ClassManifest[B]):Array[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toArray</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: ClassManifest[B]</span>)</span><span class="result">: <span name="scala.Array" class="extype">Array</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#toBuffer" data-isabs="false">
      <a id="toBuffer[C&gt;:(Key, Deque[List[Term]])]:Buffer[C]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toBuffer</span><span class="tparams">[<span name="C">C &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="result">: <span name="scala.collection.mutable.Buffer" class="extype">Buffer</span>[C]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="prt" name="scala.collection.IterableLike#toCollection" data-isabs="false">
      <a id="toCollection(LinkedHashMap[Key, Deque[List[Term]]]):Iterable[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toCollection</span><span class="params">(<span name="repr">repr: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>)</span><span class="result">: <span name="scala.collection.Iterable" class="extype">Iterable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[this] </dd><dt>Definition Classes</dt><dd>IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toIndexedSeq" data-isabs="false">
      <a id="toIndexedSeq[B&gt;:(Key, Deque[List[Term]])]:IndexedSeq[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toIndexedSeq</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="result">: <span name="scala.collection.immutable.IndexedSeq" class="extype">IndexedSeq</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#toIterable" data-isabs="false">
      <a id="toIterable:Iterable[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toIterable</span><span class="result">: <span name="scala.collection.Iterable" class="extype">Iterable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#toIterator" data-isabs="false">
      <a id="toIterator:Iterator[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toIterator</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toList" data-isabs="false">
      <a id="toList:List[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toList</span><span class="result">: List[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toMap" data-isabs="false">
      <a id="toMap[T, U](&lt;:&lt;[(Key, Deque[List[Term]]), (T, U)]):Map[T, U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toMap</span><span class="tparams">[<span name="T">T</span>, <span name="U">U</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="ev">ev: <span name="scala.Predef.&lt;:&lt;" class="extype">&lt;:&lt;</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), (T, U)]</span>)</span><span class="result">: <span name="scala.collection.immutable.Map" class="extype">Map</span>[T, U]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#toSeq" data-isabs="false">
      <a id="toSeq:Seq[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toSeq</span><span class="result">: <span name="scala.collection.Seq" class="extype">Seq</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableOnce#toSet" data-isabs="false">
      <a id="toSet[B&gt;:(Key, Deque[List[Term]])]:Set[B]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toSet</span><span class="tparams">[<span name="B">B &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>]</span><span class="result">: <span name="scala.collection.immutable.Set" class="extype">Set</span>[B]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#toStream" data-isabs="false">
      <a id="toStream:Stream[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toStream</span><span class="result">: <span name="scala.collection.immutable.Stream" class="extype">Stream</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#toString" data-isabs="false">
      <a id="toString():String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toString</span><span class="params">()</span><span class="result">: String</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → TraversableLike → Function1 → AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#toTraversable" data-isabs="false">
      <a id="toTraversable:Traversable[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toTraversable</span><span class="result">: <span name="scala.collection.Traversable" class="extype">Traversable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → TraversableOnce → GenTraversableOnce</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#transform" data-isabs="false">
      <a id="transform((Key, Deque[List[Term]]) ⇒ Deque[List[Term]]):DataBase.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">transform</span><span class="params">(<span name="f">f: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]) ⇒ <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>)</span><span class="result">: DataBase.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#transpose" data-isabs="false">
      <a id="transpose[B](((Key, Deque[List[Term]])) ⇒ GenTraversableOnce[B]):Iterable[Iterable[B]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">transpose</span><span class="tparams">[<span name="B">B</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="asTraversable">asTraversable: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[B]</span>)</span><span class="result">: <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[<span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[B]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.9.0)</i> <code>transpose</code> throws an <code>IllegalArgumentException</code> if collections are not uniformly sized.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#unzip" data-isabs="false">
      <a id="unzip[A1, A2](((Key, Deque[List[Term]])) ⇒ (A1, A2)):(Iterable[A1], Iterable[A2])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">unzip</span><span class="tparams">[<span name="A1">A1</span>, <span name="A2">A2</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="asPair">asPair: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ (A1, A2)</span>)</span><span class="result">: (<span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[A1], <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[A2])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.generic.GenericTraversableTemplate#unzip3" data-isabs="false">
      <a id="unzip3[A1, A2, A3](((Key, Deque[List[Term]])) ⇒ (A1, A2, A3)):(Iterable[A1], Iterable[A2], Iterable[A3])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">unzip3</span><span class="tparams">[<span name="A1">A1</span>, <span name="A2">A2</span>, <span name="A3">A3</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="asTriple">asTriple: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ (A1, A2, A3)</span>)</span><span class="result">: (<span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[A1], <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[A2], <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[A3])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>GenericTraversableTemplate</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#update" data-isabs="false">
      <a id="update(Key,Deque[List[Term]]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">update</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="value">value: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#updated" data-isabs="false">
      <a id="updated[B1&gt;:Deque[List[Term]]](Key,B1):Map[Key, B1]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">updated</span><span class="tparams">[<span name="B1">B1 &gt;: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>]</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>, <span name="value">value: B1</span>)</span><span class="result">: <span name="scala.collection.mutable.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, B1]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike → MapLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#values" data-isabs="false">
      <a id="values:Iterable[Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">values</span><span class="result">: <span name="scala.collection.Iterable" class="extype">Iterable</span>[<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd><dt>Annotations</dt><dd>
                <span class="name">@migration</span>
              
        </dd><dt>Migration</dt><dd class="cmt"><p><i>(Changed in version 2.8.0)</i> <code>values</code> returns <code>Iterable[B]</code> rather than <code>Iterator[B]</code>.</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.LinkedHashMap#valuesIterator" data-isabs="false">
      <a id="valuesIterator:Iterator[Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">valuesIterator</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>LinkedHashMap → MapLike</dd></dl></div>
    </li><li visbl="pub" name="prolog.fluents.DataBase#vars" data-isabs="false">
      <a id="vars:LinkedHashMap[String, Var]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">vars</span><span class="result">: <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[String, <a name="prolog.terms.Var" class="extype" href="../terms/Var.html">Var</a>]</span>
      </span>
      </h4>
      
    </li><li visbl="pub" name="scala.collection.IterableLike#view" data-isabs="false">
      <a id="view(Int,Int):IterableView[(Key, Deque[List[Term]]), LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">view</span><span class="params">(<span name="from">from: <span name="scala.Int" class="extype">Int</span></span>, <span name="until">until: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.collection.IterableView" class="extype">IterableView</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#view" data-isabs="false">
      <a id="view:IterableView[(Key, Deque[List[Term]]), LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">view</span><span class="result">: <span name="scala.collection.IterableView" class="extype">IterableView</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → TraversableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long,Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>, <span name="arg1">arg1: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Map#withDefault" data-isabs="false">
      <a id="withDefault((Key) ⇒ Deque[List[Term]]):Map[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">withDefault</span><span class="params">(<span name="d">d: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>) ⇒ <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>)</span><span class="result">: <span name="scala.collection.mutable.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Map</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.Map#withDefaultValue" data-isabs="false">
      <a id="withDefaultValue(Deque[List[Term]]):Map[Key, Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">withDefaultValue</span><span class="params">(<span name="d">d: <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</span>)</span><span class="result">: <span name="scala.collection.mutable.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Map</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.TraversableLike#withFilter" data-isabs="false">
      <a id="withFilter(((Key, Deque[List[Term]])) ⇒ Boolean):FilterMonadic[(Key, Deque[List[Term]]), LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">withFilter</span><span class="params">(<span name="p">p: ((<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])) ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <span name="scala.collection.generic.FilterMonadic" class="extype">FilterMonadic</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>TraversableLike → FilterMonadic</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zip" data-isabs="false">
      <a id="zip[A1&gt;:(Key, Deque[List[Term]]), B, That](GenIterable[B])(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zip</span><span class="tparams">[<span name="A1">A1 &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>, <span name="B">B</span>, <span name="That">That</span>]</span><span class="params">(<span name="that">that: <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[B]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zipAll" data-isabs="false">
      <a id="zipAll[B, A1&gt;:(Key, Deque[List[Term]]), That](GenIterable[B],A1,B)(CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], (A1, B), That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipAll</span><span class="tparams">[<span name="B">B</span>, <span name="A1">A1 &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>, <span name="That">That</span>]</span><span class="params">(<span name="that">that: <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[B]</span>, <span name="thisElem">thisElem: A1</span>, <span name="thatElem">thatElem: B</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], (A1, B), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → GenIterableLike</dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#zipWithIndex" data-isabs="false">
      <a id="zipWithIndex[A1&gt;:(Key, Deque[List[Term]]), That](CanBuildFrom[LinkedHashMap[Key, Deque[List[Term]]], (A1, Int), That]):That"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipWithIndex</span><span class="tparams">[<span name="A1">A1 &gt;: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>, <span name="That">That</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="bf">bf: <span name="scala.collection.generic.CanBuildFrom" class="extype">CanBuildFrom</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]], (A1, <span name="scala.Int" class="extype">Int</span>), That]</span>)</span><span class="result">: That</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike → GenIterableLike</dd></dl></div>
    </li></ol>
            </div>

        <div class="values members" id="values">
              <h3>Deprecated Value Members</h3>
              <ol><li visbl="pub" name="scala.collection.IterableLike#elements" data-isabs="false">
      <a id="elements:Iterator[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use iterator' instead">elements</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use <code>iterator' instead</code></p></dd></dl></div>
    </li><li visbl="prt" name="scala.collection.mutable.HashTable#entries" data-isabs="false">
      <a id="entries:Iterator[LinkedEntry[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use entriesIterator instead">entries</span><span class="result">: <span name="scala.collection.Iterator" class="extype">Iterator</span>[<span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>HashTable</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use entriesIterator instead</p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#first" data-isabs="false">
      <a id="first:(Key, Deque[List[Term]])"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use head' instead">first</span><span class="result">: (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use <code>head' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#firstOption" data-isabs="false">
      <a id="firstOption:Option[(Key, Deque[List[Term]])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use headOption' instead">firstOption</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use <code>headOption' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.MapLike#mapElements" data-isabs="false">
      <a id="mapElements[C]((Deque[List[Term]]) ⇒ C):Map[Key, C]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use mapValues' instead">mapElements</span><span class="tparams">[<span name="C">C</span>]</span><span class="params">(<span name="f">f: (<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]) ⇒ C</span>)</span><span class="result">: <span name="scala.collection.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, C]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use <code>mapValues' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.IterableLike#projection" data-isabs="false">
      <a id="projection:IterableView[(Key, Deque[List[Term]]), LinkedHashMap[Key, Deque[List[Term]]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) use view' instead">projection</span><span class="result">: <span name="scala.collection.IterableView" class="extype">IterableView</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>IterableLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> use <code>view' instead</code></p></dd></dl></div>
    </li><li visbl="pub" name="scala.collection.mutable.MapLike#removeKey" data-isabs="false">
      <a id="removeKey(Key):Option[Deque[List[Term]]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 2.8.0) Use remove' instead">removeKey</span><span class="params">(<span name="key">key: <a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a></span>)</span><span class="result">: <span name="scala.Option" class="extype">Option</span>[<a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>MapLike</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 2.8.0)</i> Use <code>remove' instead</code></p></dd></dl></div>
    </li></ol>
            </div>
        </div>

        <div id="inheritedMembers">
        <div name="scala.collection.mutable.LinkedHashMap" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</h3>
            </div><div name="scala.Serializable" class="parent">
              <h3>Inherited from <span name="scala.Serializable" class="extype">Serializable</span></h3>
            </div><div name="java.io.Serializable" class="parent">
              <h3>Inherited from <span name="java.io.Serializable" class="extype">Serializable</span></h3>
            </div><div name="scala.collection.mutable.HashTable" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.HashTable" class="extype">HashTable</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <span name="scala.collection.mutable.LinkedEntry" class="extype">LinkedEntry</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.mutable.HashTable.HashUtils" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.HashTable.HashUtils" class="extype">HashUtils</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>]</h3>
            </div><div name="scala.collection.mutable.Map" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</h3>
            </div><div name="scala.collection.mutable.MapLike" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.MapLike" class="extype">MapLike</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]], <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.mutable.Cloneable" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Cloneable" class="extype">Cloneable</span>[<span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.generic.Shrinkable" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.Shrinkable" class="extype">Shrinkable</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>]</h3>
            </div><div name="scala.collection.mutable.Builder" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Builder" class="extype">Builder</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.generic.Growable" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.Growable" class="extype">Growable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</h3>
            </div><div name="scala.collection.Map" class="parent">
              <h3>Inherited from <span name="scala.collection.Map" class="extype">Map</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</h3>
            </div><div name="scala.collection.MapLike" class="parent">
              <h3>Inherited from <span name="scala.collection.MapLike" class="extype">MapLike</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]], <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.generic.Subtractable" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.Subtractable" class="extype">Subtractable</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.PartialFunction" class="parent">
              <h3>Inherited from <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</h3>
            </div><div name="scala.Function1" class="parent">
              <h3>Inherited from (<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>) ⇒ <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]</h3>
            </div><div name="scala.collection.GenMap" class="parent">
              <h3>Inherited from <span name="scala.collection.GenMap" class="extype">GenMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]</h3>
            </div><div name="scala.collection.GenMapLike" class="parent">
              <h3>Inherited from <span name="scala.collection.GenMapLike" class="extype">GenMapLike</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]], <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.mutable.Iterable" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</h3>
            </div><div name="scala.collection.Iterable" class="parent">
              <h3>Inherited from <span name="scala.collection.Iterable" class="extype">Iterable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</h3>
            </div><div name="scala.collection.IterableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.IterableLike" class="extype">IterableLike</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.Equals" class="parent">
              <h3>Inherited from <span name="scala.Equals" class="extype">Equals</span></h3>
            </div><div name="scala.collection.GenIterable" class="parent">
              <h3>Inherited from <span name="scala.collection.GenIterable" class="extype">GenIterable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</h3>
            </div><div name="scala.collection.GenIterableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.GenIterableLike" class="extype">GenIterableLike</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.mutable.Traversable" class="parent">
              <h3>Inherited from <span name="scala.collection.mutable.Traversable" class="extype">Traversable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</h3>
            </div><div name="scala.Mutable" class="parent">
              <h3>Inherited from <span name="scala.Mutable" class="extype">Mutable</span></h3>
            </div><div name="scala.collection.Traversable" class="parent">
              <h3>Inherited from <span name="scala.collection.Traversable" class="extype">Traversable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</h3>
            </div><div name="scala.collection.GenTraversable" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversable" class="extype">GenTraversable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</h3>
            </div><div name="scala.collection.generic.GenericTraversableTemplate" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.GenericTraversableTemplate" class="extype">GenericTraversableTemplate</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.Iterable" class="extype">Iterable</span>]</h3>
            </div><div name="scala.collection.TraversableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.TraversableLike" class="extype">TraversableLike</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.GenTraversableLike" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversableLike" class="extype">GenTraversableLike</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.Parallelizable" class="parent">
              <h3>Inherited from <span name="scala.collection.Parallelizable" class="extype">Parallelizable</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.parallel.mutable.ParMap" class="extype">ParMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.TraversableOnce" class="parent">
              <h3>Inherited from <span name="scala.collection.TraversableOnce" class="extype">TraversableOnce</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</h3>
            </div><div name="scala.collection.GenTraversableOnce" class="parent">
              <h3>Inherited from <span name="scala.collection.GenTraversableOnce" class="extype">GenTraversableOnce</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]])]</h3>
            </div><div name="scala.collection.generic.FilterMonadic" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.FilterMonadic" class="extype">FilterMonadic</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.collection.generic.HasNewBuilder" class="parent">
              <h3>Inherited from <span name="scala.collection.generic.HasNewBuilder" class="extype">HasNewBuilder</span>[(<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]), <span name="scala.collection.mutable.LinkedHashMap" class="extype">LinkedHashMap</span>[<a name="prolog.fluents.Key" class="extype" href="Key.html">Key</a>, <a name="prolog.fluents.Deque" class="extype" href="Deque.html">Deque</a>[List[<a name="prolog.terms.Term" class="extype" href="../terms/Term.html">Term</a>]]]]</h3>
            </div><div name="scala.AnyRef" class="parent">
              <h3>Inherited from AnyRef</h3>
            </div><div name="scala.Any" class="parent">
              <h3>Inherited from <span name="scala.Any" class="extype">Any</span></h3>
            </div>
        </div>

      </div>

      <div id="tooltip"></div>

      <div id="footer">  </div>


    </body>
      </html>